home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / cocktail / rex.lha / rex / m2c / Dfa.c < prev    next >
C/C++ Source or Header  |  1992-08-18  |  40KB  |  1,391 lines
  1. #include "SYSTEM_.h"
  2.  
  3. #ifndef DEFINITION_General
  4. #include "General.h"
  5. #endif
  6.  
  7. #ifndef DEFINITION_DynArray
  8. #include "DynArray.h"
  9. #endif
  10.  
  11. #ifndef DEFINITION_Sets
  12. #include "Sets.h"
  13. #endif
  14.  
  15. #ifndef DEFINITION_IO
  16. #include "IO.h"
  17. #endif
  18.  
  19. #ifndef DEFINITION_Layout
  20. #include "Layout.h"
  21. #endif
  22.  
  23. #ifndef DEFINITION_GenTabs
  24. #include "GenTabs.h"
  25. #endif
  26.  
  27. #ifndef DEFINITION_Classes
  28. #include "Classes.h"
  29. #endif
  30.  
  31. #ifndef DEFINITION_Dfa
  32. #include "Dfa.h"
  33. #endif
  34.  
  35. CHAR Dfa_LastCh;
  36. CHAR Dfa_OldLastCh;
  37. Dfa_DStateRange Dfa_DStateCount;
  38. Dfa_DStateRange Dfa_EobState;
  39. Dfa_DStateRange Dfa_EobDefaultState;
  40. Sets_tSet Dfa_AmbiguousStates;
  41. Sets_tSet Dfa_CyclicStates;
  42. Dfa_DStateRange Dfa_MaxAmbiguousState;
  43. INTEGER Dfa_MinimizeSavings;
  44. INTEGER Dfa_DefaultSavings;
  45.  
  46. #define InitialTableSize    256
  47. typedef struct S_10 {
  48.     Dfa_DStateRange A[256];
  49. } *RowType;
  50. typedef struct S_1 {
  51.     RowType Row;
  52.     Sets_tSet Semantics;
  53.     Dfa_DStateRange Default;
  54.     Sets_tSet StartSet;
  55.     Dfa_DStateRange EobTrans;
  56.     CHAR FirstElmt;
  57.     CHAR LastElmt;
  58. } DStateInfo;
  59. typedef struct S_2 {
  60.     DStateInfo A[100000 + 1];
  61. } DStateTable;
  62. typedef struct S_3 {
  63.     Sets_tSet A[100000 + 1];
  64. } SuccSet;
  65. static DStateTable *TablePtr;
  66. static LONGINT TableSize;
  67. static SuccSet *SuccSetPtr;
  68. static LONGINT SuccSetSize;
  69. static void ReleaseDState ARGS((Dfa_DStateRange State));
  70. typedef Dfa_DStateRange BlockRange;
  71. typedef struct S_4 {
  72.     Dfa_DStateRange Partition;
  73.     SHORTCARD Card;
  74.     Sets_tSet Semantics;
  75.     BOOLEAN Used;
  76.     BlockRange MapBlockToBlock;
  77.     BlockRange MapStateToBlock;
  78.     BlockRange NewMapStateToBlock;
  79.     Dfa_DStateRange NextMember;
  80.     Dfa_DStateRange Location;
  81. } C_2_DBElmt;
  82. typedef struct S_5 {
  83.     C_2_DBElmt A[100000 + 1];
  84. } C_3_DB;
  85. static void WritePartition ARGS(());
  86. typedef struct S_6 {
  87.     SHORTCARD A[100000 + 1];
  88. } PredCount;
  89. typedef struct S_7 {
  90.     Sets_tSet A[100000 + 1];
  91. } C_1_Succ;
  92. typedef struct S_8 {
  93.     Sets_tSet Domain;
  94.     Sets_tSet Defaults;
  95.     Sets_tSet Users;
  96.     SHORTCARD Savings;
  97.     SHORTCARD DFN;
  98.     SHORTCARD DFNToState;
  99. } DBElmt;
  100. typedef struct S_9 {
  101.     DBElmt A[100000 + 1];
  102. } DB;
  103. static void DepthFirstTraversal ARGS((Dfa_DStateRange State));
  104.  
  105. static C_3_DB* *G_1_DBPtr;
  106. static BlockRange *G_2_BlockCount;
  107. static BlockRange *G_3_Block;
  108. static Dfa_DStateRange *G_4_State;
  109. static DB* *G_5_DBPtr;
  110. static Sets_tSet *G_6_WorkingSet;
  111. static Sets_tSet *G_7_Marked;
  112. static SHORTCARD *G_8_DFN;
  113. static Dfa_DStateRange *G_9_To;
  114. static Dfa_DStateRange *G_10_From;
  115.  
  116. Dfa_DStateRange Dfa_MakeDState
  117. # ifdef __STDC__
  118. ()
  119. # else
  120. ()
  121. # endif
  122. {
  123.   CHAR Ch;
  124.   LONGINT RowSize;
  125.  
  126.   INC(Dfa_DStateCount);
  127.   if ((SHORTINT)Dfa_DStateCount == TableSize) {
  128.     DynArray_ExtendArray((ADDRESS *)&TablePtr, &TableSize, (LONGINT)sizeof(DStateInfo));
  129.   }
  130.   {
  131.     register DStateInfo *W_1 = &TablePtr->A[Dfa_DStateCount];
  132.  
  133.     RowSize = ORD(Dfa_LastCh) + 1;
  134.     DynArray_MakeArray((ADDRESS *)&W_1->Row, &RowSize, (LONGINT)sizeof(Dfa_DStateRange));
  135.     {
  136.       CHAR B_1 = '\0', B_2 = Dfa_LastCh;
  137.  
  138.       if (B_1 <= B_2)
  139.         for (Ch = B_1;; Ch += 1) {
  140.           W_1->Row->A[Ch] = Dfa_DNoState;
  141.           if (Ch >= B_2) break;
  142.         }
  143.     }
  144.     Sets_MakeSet(&W_1->Semantics, (LONGCARD)GenTabs_PatternCount);
  145.     W_1->Default = Dfa_DNoState;
  146.     Sets_MakeSet(&W_1->StartSet, (LONGCARD)GenTabs_StartStateCount);
  147.     W_1->EobTrans = Dfa_DNoState;
  148.     W_1->FirstElmt = Dfa_LastCh;
  149.     W_1->LastElmt = Dfa_FirstCh;
  150.   }
  151.   return Dfa_DStateCount;
  152. }
  153.  
  154. static void ReleaseDState
  155. # ifdef __STDC__
  156. (Dfa_DStateRange State)
  157. # else
  158. (State)
  159. Dfa_DStateRange State;
  160. # endif
  161. {
  162.   LONGINT RowSize;
  163.  
  164.   DEC(Dfa_DStateCount);
  165.   RowSize = ORD(Dfa_LastCh) + 1;
  166.   DynArray_ReleaseArray((ADDRESS *)&TablePtr->A[State].Row, &RowSize, (LONGINT)sizeof(Dfa_DStateRange));
  167.   Sets_ReleaseSet(&TablePtr->A[State].Semantics);
  168.   Sets_ReleaseSet(&TablePtr->A[State].StartSet);
  169. }
  170.  
  171. Dfa_DStateRange Dfa_GetEobTrans
  172. # ifdef __STDC__
  173. (Dfa_DStateRange State)
  174. # else
  175. (State)
  176. Dfa_DStateRange State;
  177. # endif
  178. {
  179.   return TablePtr->A[State].EobTrans;
  180. }
  181.  
  182. Dfa_DStateRange Dfa_GetDefault
  183. # ifdef __STDC__
  184. (Dfa_DStateRange State)
  185. # else
  186. (State)
  187. Dfa_DStateRange State;
  188. # endif
  189. {
  190.   return TablePtr->A[State].Default;
  191. }
  192.  
  193. void Dfa_PutDefault
  194. # ifdef __STDC__
  195. (Dfa_DStateRange State, Dfa_DStateRange DefaultState)
  196. # else
  197. (State, DefaultState)
  198. Dfa_DStateRange State, DefaultState;
  199. # endif
  200. {
  201.   TablePtr->A[State].Default = DefaultState;
  202. }
  203.  
  204. void Dfa_GetDSemantics
  205. # ifdef __STDC__
  206. (Dfa_DStateRange State, Sets_tSet *Semantics)
  207. # else
  208. (State, Semantics)
  209. Dfa_DStateRange State;
  210. Sets_tSet *Semantics;
  211. # endif
  212. {
  213.   Sets_Assign(Semantics, TablePtr->A[State].Semantics);
  214. }
  215.  
  216. void Dfa_PutDSemantics
  217. # ifdef __STDC__
  218. (Dfa_DStateRange State, Sets_tSet Semantics)
  219. # else
  220. (State, Semantics)
  221. Dfa_DStateRange State;
  222. Sets_tSet Semantics;
  223. # endif
  224. {
  225.   Sets_Assign(&TablePtr->A[State].Semantics, Semantics);
  226. }
  227.  
  228. void Dfa_GetStartSet
  229. # ifdef __STDC__
  230. (Dfa_DStateRange State, Sets_tSet *StartSet)
  231. # else
  232. (State, StartSet)
  233. Dfa_DStateRange State;
  234. Sets_tSet *StartSet;
  235. # endif
  236. {
  237.   Sets_Assign(StartSet, TablePtr->A[State].StartSet);
  238. }
  239.  
  240. void Dfa_PutStartSet
  241. # ifdef __STDC__
  242. (Dfa_DStateRange State, Sets_tSet StartSet)
  243. # else
  244. (State, StartSet)
  245. Dfa_DStateRange State;
  246. Sets_tSet StartSet;
  247. # endif
  248. {
  249.   Sets_Assign(&TablePtr->A[State].StartSet, StartSet);
  250. }
  251.  
  252. Dfa_DStateRange Dfa_GetTable
  253. # ifdef __STDC__
  254. (Dfa_DStateRange State, CHAR Ch)
  255. # else
  256. (State, Ch)
  257. Dfa_DStateRange State;
  258. CHAR Ch;
  259. # endif
  260. {
  261.   Dfa_DStateRange NextState;
  262.  
  263.   do {
  264.     NextState = TablePtr->A[State].Row->A[Ch];
  265.     if (NextState != Dfa_DNoState) {
  266.       return NextState;
  267.     }
  268.     State = TablePtr->A[State].Default;
  269.   } while (!(State == Dfa_DNoState));
  270.   return Dfa_DNoState;
  271. }
  272.  
  273. void Dfa_PutTable
  274. # ifdef __STDC__
  275. (Dfa_DStateRange State, CHAR Ch, Dfa_DStateRange NextState)
  276. # else
  277. (State, Ch, NextState)
  278. Dfa_DStateRange State;
  279. CHAR Ch;
  280. Dfa_DStateRange NextState;
  281. # endif
  282. {
  283.   {
  284.     register DStateInfo *W_2 = &TablePtr->A[State];
  285.  
  286.     W_2->Row->A[Ch] = NextState;
  287.     if (NextState != Dfa_DNoState) {
  288.       if (Ch < W_2->FirstElmt) {
  289.         W_2->FirstElmt = Ch;
  290.       }
  291.       if (Ch > W_2->LastElmt) {
  292.         W_2->LastElmt = Ch;
  293.       }
  294.     } else {
  295.       if (Ch == W_2->FirstElmt && Ch < Dfa_LastCh) {
  296.         INC(W_2->FirstElmt);
  297.       }
  298.       if (Ch == W_2->LastElmt && Ch > Dfa_FirstCh) {
  299.         DEC(W_2->LastElmt);
  300.       }
  301.     }
  302.   }
  303. }
  304.  
  305. Dfa_DStateRange Dfa_GetTableNoDef
  306. # ifdef __STDC__
  307. (Dfa_DStateRange State, CHAR Ch)
  308. # else
  309. (State, Ch)
  310. Dfa_DStateRange State;
  311. CHAR Ch;
  312. # endif
  313. {
  314.   return TablePtr->A[State].Row->A[Ch];
  315. }
  316.  
  317. CHAR Dfa_GetFirst
  318. # ifdef __STDC__
  319. (Dfa_DStateRange State)
  320. # else
  321. (State)
  322. Dfa_DStateRange State;
  323. # endif
  324. {
  325.   return TablePtr->A[State].FirstElmt;
  326. }
  327.  
  328. CHAR Dfa_GetLast
  329. # ifdef __STDC__
  330. (Dfa_DStateRange State)
  331. # else
  332. (State)
  333. Dfa_DStateRange State;
  334. # endif
  335. {
  336.   return TablePtr->A[State].LastElmt;
  337. }
  338.  
  339. void Dfa_WriteDfa
  340. # ifdef __STDC__
  341. ()
  342. # else
  343. ()
  344. # endif
  345. {
  346.   Dfa_DStateRange State;
  347.   CHAR Ch;
  348.   INTEGER Count;
  349.  
  350.   IO_WriteS((System_tFile)IO_StdOutput, (STRING)"DFA :", 5L);
  351.   IO_WriteNl((System_tFile)IO_StdOutput);
  352.   IO_WriteNl((System_tFile)IO_StdOutput);
  353.   {
  354.     SHORTINT B_3 = 1, B_4 = Dfa_DStateCount;
  355.  
  356.     if (B_3 <= B_4)
  357.       for (State = B_3;; State += 1) {
  358.         IO_WriteS((System_tFile)IO_StdOutput, (STRING)"State, Default, EobTrans, Semantics, StartSet =", 47L);
  359.         IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)State, 5L);
  360.         IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)TablePtr->A[State].Default, 5L);
  361.         IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)TablePtr->A[State].EobTrans, 5L);
  362.         Layout_WriteSpace((System_tFile)IO_StdOutput);
  363.         Sets_WriteSet((System_tFile)IO_StdOutput, TablePtr->A[State].Semantics);
  364.         Layout_WriteSpace((System_tFile)IO_StdOutput);
  365.         Sets_WriteSet((System_tFile)IO_StdOutput, TablePtr->A[State].StartSet);
  366.         IO_WriteNl((System_tFile)IO_StdOutput);
  367.         Count = 0;
  368.         {
  369.           CHAR B_5 = Dfa_GetFirst(State), B_6 = Dfa_GetLast(State);
  370.  
  371.           if (B_5 <= B_6)
  372.             for (Ch = B_5;; Ch += 1) {
  373.               if (Dfa_GetTableNoDef(State, Ch) != Dfa_DNoState) {
  374.                 if (Count == 10) {
  375.                   IO_WriteNl((System_tFile)IO_StdOutput);
  376.                   Count = 0;
  377.                 }
  378.                 INC(Count);
  379.                 Layout_WriteChar((System_tFile)IO_StdOutput, Ch);
  380.                 Layout_WriteSpace((System_tFile)IO_StdOutput);
  381.                 IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)Dfa_GetTable(State, Ch), 1L);
  382.                 IO_WriteC((System_tFile)IO_StdOutput, ',');
  383.                 Layout_WriteSpace((System_tFile)IO_StdOutput);
  384.               }
  385.               if (Ch >= B_6) break;
  386.             }
  387.         }
  388.         IO_WriteNl((System_tFile)IO_StdOutput);
  389.         IO_WriteNl((System_tFile)IO_StdOutput);
  390.         if (State >= B_4) break;
  391.       }
  392.   }
  393. }
  394.  
  395. static void WritePartition
  396. # ifdef __STDC__
  397. ()
  398. # else
  399. ()
  400. # endif
  401. {
  402.   {
  403.     SHORTINT B_7 = 1, B_8 = *G_2_BlockCount;
  404.  
  405.     if (B_7 <= B_8)
  406.       for (*G_3_Block = B_7;; *G_3_Block += 1) {
  407.         IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)(*G_3_Block), 3L);
  408.         IO_WriteC((System_tFile)IO_StdOutput, ':');
  409.         *G_4_State = (*G_1_DBPtr)->A[*G_3_Block].Partition;
  410.         while (*G_4_State != Dfa_DNoState) {
  411.           IO_WriteI((System_tFile)IO_StdOutput, (LONGINT)(*G_4_State), 3L);
  412.           *G_4_State = (*G_1_DBPtr)->A[*G_4_State].NextMember;
  413.         }
  414.         IO_WriteNl((System_tFile)IO_StdOutput);
  415.         if (*G_3_Block >= B_8) break;
  416.       }
  417.   }
  418. }
  419.  
  420. void Dfa_MinimizeDfa
  421. # ifdef __STDC__
  422. ()
  423. # else
  424. ()
  425. # endif
  426. {
  427.   C_3_DB *DBPtr;
  428.   LONGINT DBSize;
  429.   BlockRange BlockCount;
  430.   BlockRange OldBlockCount;
  431.   BlockRange Block;
  432.   BlockRange TargetBlock;
  433.   BlockRange TargetBlockCount;
  434.   BlockRange i;
  435.   BlockRange Gap;
  436.   BlockRange InitGap;
  437.   BlockRange NextGap;
  438.   Sets_tSet BlockSet;
  439.   Sets_tSet dSemantics;
  440.   Dfa_DStateRange State;
  441.   Dfa_DStateRange NextState;
  442.   CHAR Ch;
  443.   SHORTCARD Pattern;
  444.   Sets_tSet dStates;
  445.   RowType InitGapRow;
  446.   C_3_DB* *L_1;
  447.   BlockRange *L_2;
  448.   BlockRange *L_3;
  449.   Dfa_DStateRange *L_4;
  450.  
  451.   L_1 = G_1_DBPtr;
  452.   G_1_DBPtr = &DBPtr;
  453.   L_2 = G_2_BlockCount;
  454.   G_2_BlockCount = &BlockCount;
  455.   L_3 = G_3_Block;
  456.   G_3_Block = &Block;
  457.   L_4 = G_4_State;
  458.   G_4_State = &State;
  459.   DBSize = Dfa_DStateCount + 2;
  460.   DynArray_MakeArray((ADDRESS *)&DBPtr, &DBSize, (LONGINT)sizeof(C_2_DBElmt));
  461.   Sets_MakeSet(&dSemantics, (LONGCARD)GenTabs_PatternCount);
  462.   Sets_MakeSet(&dStates, (LONGCARD)Dfa_DStateCount);
  463.   DBPtr->A[Dfa_DNoState].MapStateToBlock = 0;
  464.   {
  465.     SHORTINT B_9 = 1, B_10 = GenTabs_StartStateCount;
  466.  
  467.     if (B_9 <= B_10)
  468.       for (State = B_9;; State += 1) {
  469.         Block = State;
  470.         DBPtr->A[Block].Partition = State;
  471.         DBPtr->A[Block].Card = 1;
  472.         DBPtr->A[State].NextMember = Dfa_DNoState;
  473.         DBPtr->A[State].MapStateToBlock = Block;
  474.         if (State >= B_10) break;
  475.       }
  476.   }
  477.   BlockCount = GenTabs_StartStateCount;
  478.   {
  479.     SHORTINT B_11 = GenTabs_StartStateCount + 1, B_12 = Dfa_DStateCount;
  480.  
  481.     if (B_11 <= B_12)
  482.       for (State = B_11;; State += 1) {
  483.         Block = GenTabs_StartStateCount + 1;
  484.         for (;;) {
  485.           if (Block > BlockCount) {
  486.             INC(BlockCount);
  487.             Block = BlockCount;
  488.             DBPtr->A[Block].Partition = Dfa_DNoState;
  489.             DBPtr->A[Block].Card = 0;
  490.             Sets_MakeSet(&DBPtr->A[Block].Semantics, (LONGCARD)GenTabs_PatternCount);
  491.             Dfa_GetDSemantics(State, &DBPtr->A[Block].Semantics);
  492.             goto EXIT_1;
  493.           }
  494.           Dfa_GetDSemantics(State, &dSemantics);
  495.           if (Sets_IsEmpty(dSemantics) && Sets_IsEmpty(DBPtr->A[Block].Semantics) || !Sets_IsEmpty(dSemantics) && !Sets_IsEmpty(DBPtr->A[Block].Semantics) && Sets_Minimum(&dSemantics) == Sets_Minimum(&DBPtr->A[Block].Semantics)) {
  496.             goto EXIT_1;
  497.           }
  498.           INC(Block);
  499.         } EXIT_1:;
  500.         DBPtr->A[State].NextMember = DBPtr->A[Block].Partition;
  501.         DBPtr->A[Block].Partition = State;
  502.         INC(DBPtr->A[Block].Card);
  503.         DBPtr->A[State].MapStateToBlock = Block;
  504.         if (State >= B_12) break;
  505.       }
  506.   }
  507.   {
  508.     SHORTINT B_13 = GenTabs_StartStateCount + 1, B_14 = BlockCount;
  509.  
  510.     if (B_13 <= B_14)
  511.       for (Block = B_13;; Block += 1) {
  512.         Sets_ReleaseSet(&DBPtr->A[Block].Semantics);
  513.         if (Block >= B_14) break;
  514.       }
  515.   }
  516.   do {
  517.     OldBlockCount = BlockCount;
  518.     Block = GenTabs_StartStateCount + 1;
  519.     while (Block <= BlockCount) {
  520.       if (DBPtr->A[Block].Card > 1) {
  521.         {
  522.           CHAR B_15 = Dfa_FirstCh, B_16 = Dfa_LastCh;
  523.  
  524.           if (B_15 <= B_16)
  525.             for (Ch = B_15;; Ch += 1) {
  526.               TargetBlockCount = 0;
  527.               {
  528.                 SHORTINT B_17 = 0, B_18 = BlockCount;
  529.  
  530.                 if (B_17 <= B_18)
  531.                   for (i = B_17;; i += 1) {
  532.                     DBPtr->A[i].Used = FALSE;
  533.                     if (i >= B_18) break;
  534.                   }
  535.               }
  536.               State = DBPtr->A[Block].Partition;
  537.               while (State != Dfa_DNoState) {
  538.                 TargetBlock = DBPtr->A[Dfa_GetTableNoDef(State, Ch)].MapStateToBlock;
  539.                 if (!DBPtr->A[TargetBlock].Used) {
  540.                   if (TargetBlockCount == 0) {
  541.                     DBPtr->A[TargetBlock].MapBlockToBlock = Block;
  542.                   } else {
  543.                     INC(BlockCount);
  544.                     DBPtr->A[BlockCount].Partition = Dfa_DNoState;
  545.                     DBPtr->A[BlockCount].Card = 0;
  546.                     DBPtr->A[TargetBlock].MapBlockToBlock = BlockCount;
  547.                   }
  548.                   DBPtr->A[TargetBlock].Used = TRUE;
  549.                   INC(TargetBlockCount);
  550.                 }
  551.                 DBPtr->A[State].NewMapStateToBlock = DBPtr->A[TargetBlock].MapBlockToBlock;
  552.                 State = DBPtr->A[State].NextMember;
  553.               }
  554.               if (TargetBlockCount > 1) {
  555.                 State = DBPtr->A[Block].Partition;
  556.                 DBPtr->A[Block].Partition = Dfa_DNoState;
  557.                 DBPtr->A[Block].Card = 0;
  558.                 while (State != Dfa_DNoState) {
  559.                   NextState = DBPtr->A[State].NextMember;
  560.                   TargetBlock = DBPtr->A[State].NewMapStateToBlock;
  561.                   DBPtr->A[State].NextMember = DBPtr->A[TargetBlock].Partition;
  562.                   DBPtr->A[TargetBlock].Partition = State;
  563.                   INC(DBPtr->A[TargetBlock].Card);
  564.                   DBPtr->A[State].MapStateToBlock = TargetBlock;
  565.                   State = NextState;
  566.                 }
  567.               }
  568.               if (Ch >= B_16) break;
  569.             }
  570.         }
  571.       }
  572.       INC(Block);
  573.     }
  574.   } while (!(OldBlockCount == BlockCount));
  575.   {
  576.     SHORTINT B_19 = 1, B_20 = BlockCount;
  577.  
  578.     if (B_19 <= B_20)
  579.       for (Block = B_19;; Block += 1) {
  580.         State = DBPtr->A[Block].Partition;
  581.         {
  582.           CHAR B_21 = Dfa_GetFirst(State), B_22 = Dfa_GetLast(State);
  583.  
  584.           if (B_21 <= B_22)
  585.             for (Ch = B_21;; Ch += 1) {
  586.               NextState = Dfa_GetTableNoDef(State, Ch);
  587.               if (NextState != Dfa_DNoState) {
  588.                 Dfa_PutTable(State, Ch, DBPtr->A[NextState].MapStateToBlock);
  589.               }
  590.               if (Ch >= B_22) break;
  591.             }
  592.         }
  593.         if (Block >= B_20) break;
  594.       }
  595.   }
  596.   Sets_MakeSet(&BlockSet, (LONGCARD)BlockCount);
  597.   Sets_Complement(&BlockSet);
  598.   Sets_Exclude(&BlockSet, (LONGCARD)Dfa_DNoState);
  599.   {
  600.     SHORTINT B_23 = 1, B_24 = Dfa_DStateCount;
  601.  
  602.     if (B_23 <= B_24)
  603.       for (State = B_23;; State += 1) {
  604.         DBPtr->A[State].Location = State;
  605.         if (State >= B_24) break;
  606.       }
  607.   }
  608.   InitGap = Dfa_MakeDState();
  609.   InitGapRow = TablePtr->A[InitGap].Row;
  610.   while (!Sets_IsEmpty(BlockSet)) {
  611.     Block = Sets_Extract(&BlockSet);
  612.     if (Block != DBPtr->A[Block].Partition) {
  613.       TablePtr->A[InitGap].Row = TablePtr->A[Block].Row;
  614.       TablePtr->A[InitGap].FirstElmt = TablePtr->A[Block].FirstElmt;
  615.       TablePtr->A[InitGap].LastElmt = TablePtr->A[Block].LastElmt;
  616.       Dfa_GetDSemantics(Block, &dSemantics);
  617.       Dfa_PutDSemantics(InitGap, dSemantics);
  618.       DBPtr->A[Block].Location = InitGap;
  619.       Gap = Block;
  620.       do {
  621.         NextGap = DBPtr->A[DBPtr->A[Gap].Partition].Location;
  622.         TablePtr->A[Gap].Row = TablePtr->A[NextGap].Row;
  623.         TablePtr->A[Gap].FirstElmt = TablePtr->A[NextGap].FirstElmt;
  624.         TablePtr->A[Gap].LastElmt = TablePtr->A[NextGap].LastElmt;
  625.         Dfa_GetDSemantics(NextGap, &dSemantics);
  626.         Dfa_PutDSemantics(Gap, dSemantics);
  627.         Sets_Exclude(&BlockSet, (LONGCARD)Gap);
  628.         Gap = NextGap;
  629.       } while (!(Gap > BlockCount));
  630.       InitGap = Gap;
  631.     }
  632.   }
  633.   TablePtr->A[InitGap].Row = InitGapRow;
  634.   {
  635.     SHORTCARD B_25 = 1, B_26 = GenTabs_PatternCount - 2;
  636.  
  637.     if (B_25 <= B_26)
  638.       for (Pattern = B_25;; Pattern += 1) {
  639.         if (GenTabs_PatternTablePtr->A[Pattern].ContextLng == GenTabs_VariableContext) {
  640.           Sets_Assign(&dStates, GenTabs_PatternTablePtr->A[Pattern].DContext);
  641.           Sets_AssignEmpty(&GenTabs_PatternTablePtr->A[Pattern].DContext);
  642.           while (!Sets_IsEmpty(dStates)) {
  643.             State = DBPtr->A[Sets_Extract(&dStates)].MapStateToBlock;
  644.             Sets_Include(&GenTabs_PatternTablePtr->A[Pattern].DContext, (LONGCARD)State);
  645.           }
  646.         }
  647.         if (Pattern >= B_26) break;
  648.       }
  649.   }
  650.   Dfa_MinimizeSavings = Dfa_DStateCount - BlockCount;
  651.   Sets_ReleaseSet(&BlockSet);
  652.   Sets_ReleaseSet(&dSemantics);
  653.   Sets_ReleaseSet(&dStates);
  654.   {
  655.     SHORTINT B_27 = Dfa_DStateCount, B_28 = BlockCount + 1;
  656.  
  657.     if (B_27 >= B_28)
  658.       for (State = B_27;; State += -1) {
  659.         ReleaseDState(State);
  660.         if (State <= B_28) break;
  661.       }
  662.   }
  663.   DynArray_ReleaseArray((ADDRESS *)&DBPtr, &DBSize, (LONGINT)sizeof(C_2_DBElmt));
  664.   G_1_DBPtr = L_1;
  665.   G_2_BlockCount = L_2;
  666.   G_3_Block = L_3;
  667.   G_4_State = L_4;
  668. }
  669.  
  670. void Dfa_ComputeSuccGraph
  671. # ifdef __STDC__
  672. ()
  673. # else
  674. ()
  675. # endif
  676. {
  677.   Dfa_DStateRange State;
  678.   Dfa_DStateRange NextState;
  679.   CHAR Ch;
  680.  
  681.   SuccSetSize = Dfa_DStateCount + 1;
  682.   DynArray_MakeArray((ADDRESS *)&SuccSetPtr, &SuccSetSize, (LONGINT)sizeof(Sets_tSet));
  683.   {
  684.     SHORTINT B_29 = 1, B_30 = Dfa_DStateCount;
  685.  
  686.     if (B_29 <= B_30)
  687.       for (State = B_29;; State += 1) {
  688.         Sets_MakeSet(&SuccSetPtr->A[State], (LONGCARD)Dfa_DStateCount);
  689.         {
  690.           CHAR B_31 = Dfa_GetFirst(State), B_32 = Dfa_GetLast(State);
  691.  
  692.           if (B_31 <= B_32)
  693.             for (Ch = B_31;; Ch += 1) {
  694.               NextState = Dfa_GetTableNoDef(State, Ch);
  695.               if (NextState != Dfa_DNoState) {
  696.                 Sets_Include(&SuccSetPtr->A[State], (LONGCARD)NextState);
  697.               }
  698.               if (Ch >= B_32) break;
  699.             }
  700.         }
  701.         if (State >= B_30) break;
  702.       }
  703.   }
  704. }
  705.  
  706. void Dfa_ComputeAmbiguousStates
  707. # ifdef __STDC__
  708. ()
  709. # else
  710. ()
  711. # endif
  712. {
  713.   PredCount *PredCountPtr;
  714.   LONGINT PredCountSize;
  715.   PredCount *PredCount2Ptr;
  716.   LONGINT PredCount2Size;
  717.   Dfa_DStateRange State, State2;
  718.   Dfa_DStateRange Successor;
  719.   Sets_tSet UnambiguousStates;
  720.   CHAR Ch;
  721.  
  722.   PredCountSize = Dfa_DStateCount + 1;
  723.   DynArray_MakeArray((ADDRESS *)&PredCountPtr, &PredCountSize, (LONGINT)sizeof(SHORTCARD));
  724.   PredCount2Size = Dfa_DStateCount + 1;
  725.   DynArray_MakeArray((ADDRESS *)&PredCount2Ptr, &PredCount2Size, (LONGINT)sizeof(SHORTCARD));
  726.   Dfa_MaxAmbiguousState = Dfa_DStateCount;
  727.   Sets_MakeSet(&UnambiguousStates, (LONGCARD)Dfa_MaxAmbiguousState);
  728.   Sets_MakeSet(&Dfa_AmbiguousStates, (LONGCARD)Dfa_MaxAmbiguousState);
  729.   {
  730.     SHORTINT B_33 = 0, B_34 = Dfa_DStateCount;
  731.  
  732.     if (B_33 <= B_34)
  733.       for (State = B_33;; State += 1) {
  734.         PredCountPtr->A[State] = 0;
  735.         if (State >= B_34) break;
  736.       }
  737.   }
  738.   {
  739.     SHORTINT B_35 = 1, B_36 = GenTabs_StartStateCount;
  740.  
  741.     if (B_35 <= B_36)
  742.       for (State = B_35;; State += 1) {
  743.         {
  744.           SHORTINT B_37 = 0, B_38 = Dfa_DStateCount;
  745.  
  746.           if (B_37 <= B_38)
  747.             for (State2 = B_37;; State2 += 1) {
  748.               PredCount2Ptr->A[State2] = 0;
  749.               if (State2 >= B_38) break;
  750.             }
  751.         }
  752.         {
  753.           CHAR B_39 = Dfa_GetFirst(State), B_40 = Dfa_GetLast(State);
  754.  
  755.           if (B_39 <= B_40)
  756.             for (Ch = B_39;; Ch += 1) {
  757.               Successor = Dfa_GetTableNoDef(State, Ch);
  758.               if (Successor != Dfa_DNoState) {
  759.                 INC(PredCount2Ptr->A[Successor]);
  760.               }
  761.               if (Ch >= B_40) break;
  762.             }
  763.         }
  764.         {
  765.           SHORTINT B_41 = 0, B_42 = Dfa_DStateCount;
  766.  
  767.           if (B_41 <= B_42)
  768.             for (State2 = B_41;; State2 += 1) {
  769.               PredCountPtr->A[State2] = General_Max((LONGINT)PredCountPtr->A[State2], (LONGINT)PredCount2Ptr->A[State2]);
  770.               if (State2 >= B_42) break;
  771.             }
  772.         }
  773.         if (State >= B_36) break;
  774.       }
  775.   }
  776.   {
  777.     SHORTINT B_43 = GenTabs_StartStateCount + 1, B_44 = Dfa_DStateCount;
  778.  
  779.     if (B_43 <= B_44)
  780.       for (State = B_43;; State += 1) {
  781.         {
  782.           CHAR B_45 = Dfa_GetFirst(State), B_46 = Dfa_GetLast(State);
  783.  
  784.           if (B_45 <= B_46)
  785.             for (Ch = B_45;; Ch += 1) {
  786.               Successor = Dfa_GetTableNoDef(State, Ch);
  787.               if (Successor != Dfa_DNoState) {
  788.                 INC(PredCountPtr->A[Successor]);
  789.               }
  790.               if (Ch >= B_46) break;
  791.             }
  792.         }
  793.         if (State >= B_44) break;
  794.       }
  795.   }
  796.   {
  797.     SHORTINT B_47 = 1, B_48 = GenTabs_StartStateCount;
  798.  
  799.     if (B_47 <= B_48)
  800.       for (State = B_47;; State += 1) {
  801.         Sets_Include(&UnambiguousStates, (LONGCARD)State);
  802.         if (State >= B_48) break;
  803.       }
  804.   }
  805.   Sets_Complement(&Dfa_AmbiguousStates);
  806.   Sets_Exclude(&Dfa_AmbiguousStates, (LONGCARD)Dfa_DNoState);
  807.   while (!Sets_IsEmpty(UnambiguousStates)) {
  808.     State = Sets_Extract(&UnambiguousStates);
  809.     Sets_Exclude(&Dfa_AmbiguousStates, (LONGCARD)State);
  810.     {
  811.       SHORTINT B_49 = 1, B_50 = Dfa_DStateCount;
  812.  
  813.       if (B_49 <= B_50)
  814.         for (Successor = B_49;; Successor += 1) {
  815.           if (Sets_IsElement((LONGCARD)Successor, &SuccSetPtr->A[State])) {
  816.             if (PredCountPtr->A[Successor] == 1) {
  817.               Sets_Include(&UnambiguousStates, (LONGCARD)Successor);
  818.             }
  819.           }
  820.           if (Successor >= B_50) break;
  821.         }
  822.     }
  823.   }
  824.   Sets_ReleaseSet(&UnambiguousStates);
  825.   DynArray_ReleaseArray((ADDRESS *)&PredCountPtr, &PredCountSize, (LONGINT)sizeof(SHORTCARD));
  826.   DynArray_ReleaseArray((ADDRESS *)&PredCount2Ptr, &PredCount2Size, (LONGINT)sizeof(SHORTCARD));
  827. }
  828.  
  829. void Dfa_ComputeCyclicStates
  830. # ifdef __STDC__
  831. ()
  832. # else
  833. ()
  834. # endif
  835. {
  836.   C_1_Succ *SuccPtr;
  837.   LONGINT SuccSize;
  838.   Dfa_DStateRange State;
  839.   Dfa_DStateRange i, j;
  840.  
  841.   SuccSize = Dfa_DStateCount + 1;
  842.   DynArray_MakeArray((ADDRESS *)&SuccPtr, &SuccSize, (LONGINT)sizeof(Sets_tSet));
  843.   {
  844.     SHORTINT B_51 = 1, B_52 = Dfa_DStateCount;
  845.  
  846.     if (B_51 <= B_52)
  847.       for (State = B_51;; State += 1) {
  848.         Sets_MakeSet(&SuccPtr->A[State], (LONGCARD)Dfa_DStateCount);
  849.         Sets_Assign(&SuccPtr->A[State], SuccSetPtr->A[State]);
  850.         if (State >= B_52) break;
  851.       }
  852.   }
  853.   {
  854.     SHORTINT B_53 = 1, B_54 = Dfa_DStateCount;
  855.  
  856.     if (B_53 <= B_54)
  857.       for (j = B_53;; j += 1) {
  858.         {
  859.           SHORTINT B_55 = 1, B_56 = Dfa_DStateCount;
  860.  
  861.           if (B_55 <= B_56)
  862.             for (i = B_55;; i += 1) {
  863.               if (Sets_IsElement((LONGCARD)j, &SuccPtr->A[i])) {
  864.                 Sets_Union(&SuccPtr->A[i], SuccPtr->A[j]);
  865.               }
  866.               if (i >= B_56) break;
  867.             }
  868.         }
  869.         if (j >= B_54) break;
  870.       }
  871.   }
  872.   Sets_MakeSet(&Dfa_CyclicStates, (LONGCARD)Dfa_DStateCount);
  873.   {
  874.     SHORTINT B_57 = 1, B_58 = Dfa_DStateCount;
  875.  
  876.     if (B_57 <= B_58)
  877.       for (State = B_57;; State += 1) {
  878.         if (Sets_IsElement((LONGCARD)State, &SuccPtr->A[State])) {
  879.           Sets_Include(&Dfa_CyclicStates, (LONGCARD)State);
  880.         }
  881.         Sets_ReleaseSet(&SuccPtr->A[State]);
  882.         if (State >= B_58) break;
  883.       }
  884.   }
  885.   DynArray_ReleaseArray((ADDRESS *)&SuccPtr, &SuccSize, (LONGINT)sizeof(Sets_tSet));
  886. }
  887.  
  888. void Dfa_ComputeStartSets
  889. # ifdef __STDC__
  890. ()
  891. # else
  892. ()
  893. # endif
  894. {
  895.   Dfa_DStateRange State1, State2;
  896.   Sets_tSet StartSet1, StartSet2, WorkingSet;
  897.  
  898.   Sets_MakeSet(&StartSet1, (LONGCARD)GenTabs_StartStateCount);
  899.   Sets_MakeSet(&StartSet2, (LONGCARD)GenTabs_StartStateCount);
  900.   Sets_MakeSet(&WorkingSet, (LONGCARD)Dfa_DStateCount);
  901.   {
  902.     SHORTINT B_59 = 1, B_60 = GenTabs_StartStateCount;
  903.  
  904.     if (B_59 <= B_60)
  905.       for (State1 = B_59;; State1 += 1) {
  906.         {
  907.           SHORTINT B_61 = 1, B_62 = Dfa_DStateCount;
  908.  
  909.           if (B_61 <= B_62)
  910.             for (State2 = B_61;; State2 += 1) {
  911.               if (Sets_IsElement((LONGCARD)State2, &SuccSetPtr->A[State1])) {
  912.                 Dfa_GetStartSet(State2, &StartSet2);
  913.                 Sets_Include(&StartSet2, (LONGCARD)State1);
  914.                 Dfa_PutStartSet(State2, StartSet2);
  915.               }
  916.               if (State2 >= B_62) break;
  917.             }
  918.         }
  919.         Sets_Union(&WorkingSet, SuccSetPtr->A[State1]);
  920.         if (State1 >= B_60) break;
  921.       }
  922.   }
  923.   while (!Sets_IsEmpty(WorkingSet)) {
  924.     State1 = Sets_Extract(&WorkingSet);
  925.     Dfa_GetStartSet(State1, &StartSet1);
  926.     {
  927.       SHORTINT B_63 = 1, B_64 = Dfa_DStateCount;
  928.  
  929.       if (B_63 <= B_64)
  930.         for (State2 = B_63;; State2 += 1) {
  931.           if (Sets_IsElement((LONGCARD)State2, &SuccSetPtr->A[State1])) {
  932.             Dfa_GetStartSet(State2, &StartSet2);
  933.             if (!Sets_IsSubset(StartSet1, StartSet2)) {
  934.               Sets_Union(&StartSet2, StartSet1);
  935.               Dfa_PutStartSet(State2, StartSet2);
  936.               Sets_Include(&WorkingSet, (LONGCARD)State2);
  937.             }
  938.           }
  939.           if (State2 >= B_64) break;
  940.         }
  941.     }
  942.   }
  943.   Sets_ReleaseSet(&StartSet1);
  944.   Sets_ReleaseSet(&StartSet2);
  945.   Sets_ReleaseSet(&WorkingSet);
  946. }
  947.  
  948. void Dfa_SaveEobTransitions
  949. # ifdef __STDC__
  950. ()
  951. # else
  952. ()
  953. # endif
  954. {
  955.   Dfa_DStateRange State;
  956.  
  957.   {
  958.     SHORTINT B_65 = 1, B_66 = Dfa_DStateCount;
  959.  
  960.     if (B_65 <= B_66)
  961.       for (State = B_65;; State += 1) {
  962.         TablePtr->A[State].EobTrans = Dfa_GetTable(State, Classes_ToClass.A[Dfa_EobCh]);
  963.         if (State >= B_66) break;
  964.       }
  965.   }
  966.   {
  967.     SHORTINT B_67 = 1, B_68 = Dfa_MaxAmbiguousState;
  968.  
  969.     if (B_67 <= B_68)
  970.       for (State = B_67;; State += 1) {
  971.         Dfa_PutTable(State, Classes_ToClass.A[Dfa_EobCh], Dfa_EobState);
  972.         if (State >= B_68) break;
  973.       }
  974.   }
  975.   {
  976.     SHORTINT B_69 = Dfa_MaxAmbiguousState + 1, B_70 = Dfa_DStateCount;
  977.  
  978.     if (B_69 <= B_70)
  979.       for (State = B_69;; State += 1) {
  980.         Dfa_PutTable(State, Classes_ToClass.A[Dfa_EobCh], Dfa_DNoState);
  981.         if (State >= B_70) break;
  982.       }
  983.   }
  984. }
  985.  
  986. static void DepthFirstTraversal
  987. # ifdef __STDC__
  988. (Dfa_DStateRange State)
  989. # else
  990. (State)
  991. Dfa_DStateRange State;
  992. # endif
  993. {
  994.   Dfa_DStateRange State2;
  995.  
  996.   Sets_Exclude(G_6_WorkingSet, (LONGCARD)State);
  997.   Sets_Include(G_7_Marked, (LONGCARD)State);
  998.   {
  999.     SHORTINT B_71 = *G_10_From, B_72 = *G_9_To;
  1000.  
  1001.     if (B_71 <= B_72)
  1002.       for (State2 = B_71;; State2 += 1) {
  1003.         if (Sets_IsElement((LONGCARD)State2, &(*G_5_DBPtr)->A[State].Defaults) && !Sets_IsElement((LONGCARD)State2, G_7_Marked)) {
  1004.           DepthFirstTraversal(State2);
  1005.         }
  1006.         if (State2 >= B_72) break;
  1007.       }
  1008.   }
  1009.   INC(*G_8_DFN);
  1010.   (*G_5_DBPtr)->A[State].DFN = *G_8_DFN;
  1011.   (*G_5_DBPtr)->A[*G_8_DFN].DFNToState = State;
  1012. }
  1013.  
  1014. void Dfa_ComputeDefaults
  1015. # ifdef __STDC__
  1016. (Dfa_DStateRange From, Dfa_DStateRange To)
  1017. # else
  1018. (From, To)
  1019. Dfa_DStateRange From, To;
  1020. # endif
  1021. {
  1022.   DB *DBPtr;
  1023.   LONGINT DBSize;
  1024.   Dfa_DStateRange State, State1, State2, DefaultState;
  1025.   SHORTCARD DefaultCard;
  1026.   CHAR Ch;
  1027.   Sets_tSet Domain1, Domain2;
  1028.   Sets_tSet Marked, WorkingSet;
  1029.   Sets_tSet Cyclics, Current;
  1030.   Sets_tSet Next, Successors;
  1031.   SHORTCARD DFN;
  1032.   CARDINAL i;
  1033.   DB* *L_5;
  1034.   Sets_tSet *L_6;
  1035.   Sets_tSet *L_7;
  1036.   SHORTCARD *L_8;
  1037.   Dfa_DStateRange *L_9;
  1038.   Dfa_DStateRange *L_10;
  1039.  
  1040.   L_5 = G_5_DBPtr;
  1041.   G_5_DBPtr = &DBPtr;
  1042.   L_6 = G_6_WorkingSet;
  1043.   G_6_WorkingSet = &WorkingSet;
  1044.   L_7 = G_7_Marked;
  1045.   G_7_Marked = &Marked;
  1046.   L_8 = G_8_DFN;
  1047.   G_8_DFN = &DFN;
  1048.   L_9 = G_9_To;
  1049.   G_9_To = &To;
  1050.   L_10 = G_10_From;
  1051.   G_10_From = &From;
  1052.   DBSize = To + 1;
  1053.   DynArray_MakeArray((ADDRESS *)&DBPtr, &DBSize, (LONGINT)sizeof(DBElmt));
  1054.   Sets_MakeSet(&Domain1, ORD(Dfa_LastCh));
  1055.   Sets_MakeSet(&Domain2, ORD(Dfa_LastCh));
  1056.   Sets_MakeSet(&Marked, (LONGCARD)To);
  1057.   Sets_MakeSet(&WorkingSet, (LONGCARD)To);
  1058.   Sets_MakeSet(&Cyclics, (LONGCARD)To);
  1059.   Sets_MakeSet(&Current, (LONGCARD)To);
  1060.   Sets_MakeSet(&Next, (LONGCARD)To);
  1061.   Sets_MakeSet(&Successors, (LONGCARD)To);
  1062.   Dfa_DefaultSavings = 0;
  1063.   {
  1064.     SHORTINT B_73 = From, B_74 = To;
  1065.  
  1066.     if (B_73 <= B_74)
  1067.       for (State = B_73;; State += 1) {
  1068.         Sets_MakeSet(&DBPtr->A[State].Domain, ORD(Dfa_LastCh));
  1069.         {
  1070.           CHAR B_75 = Dfa_GetFirst(State), B_76 = Dfa_GetLast(State);
  1071.  
  1072.           if (B_75 <= B_76)
  1073.             for (Ch = B_75;; Ch += 1) {
  1074.               if (Dfa_GetTable(State, Ch) != Dfa_DNoState) {
  1075.                 Sets_Include(&DBPtr->A[State].Domain, ORD(Ch));
  1076.               }
  1077.               if (Ch >= B_76) break;
  1078.             }
  1079.         }
  1080.         if (State >= B_74) break;
  1081.       }
  1082.   }
  1083.   {
  1084.     SHORTINT B_77 = From, B_78 = To;
  1085.  
  1086.     if (B_77 <= B_78)
  1087.       for (State1 = B_77;; State1 += 1) {
  1088.         Sets_MakeSet(&DBPtr->A[State1].Defaults, (LONGCARD)To);
  1089.         Sets_MakeSet(&DBPtr->A[State1].Users, (LONGCARD)To);
  1090.         DBPtr->A[State1].Savings = 0;
  1091.         if (!Sets_IsEmpty(DBPtr->A[State1].Domain)) {
  1092.           Sets_Assign(&Domain1, DBPtr->A[State1].Domain);
  1093.           {
  1094.             SHORTINT B_79 = From, B_80 = To;
  1095.  
  1096.             if (B_79 <= B_80)
  1097.               for (State2 = B_79;; State2 += 1) {
  1098.                 if (State1 != State2) {
  1099.                   Sets_Assign(&Domain2, DBPtr->A[State2].Domain);
  1100.                   if (Sets_IsSubset(Domain2, Domain1)) {
  1101.                     if (Sets_Card(&DBPtr->A[State2].Domain) >= DBPtr->A[State1].Savings) {
  1102.                       {
  1103.                         CHAR B_81 = Dfa_GetFirst(State2), B_82 = Dfa_GetLast(State2);
  1104.  
  1105.                         if (B_81 <= B_82)
  1106.                           for (Ch = B_81;; Ch += 1) {
  1107.                             State = Dfa_GetTable(State2, Ch);
  1108.                             if (State != Dfa_DNoState && State != Dfa_GetTable(State1, Ch)) {
  1109.                               Sets_Exclude(&Domain2, ORD(Ch));
  1110.                             }
  1111.                             if (Ch >= B_82) break;
  1112.                           }
  1113.                       }
  1114.                       DefaultCard = Sets_Card(&Domain2);
  1115.                       if (DefaultCard > 0) {
  1116.                         if (DefaultCard == DBPtr->A[State1].Savings) {
  1117.                           Sets_Include(&DBPtr->A[State1].Defaults, (LONGCARD)State2);
  1118.                         } else if (DefaultCard > DBPtr->A[State1].Savings) {
  1119.                           Sets_AssignElmt(&DBPtr->A[State1].Defaults, (LONGCARD)State2);
  1120.                           DBPtr->A[State1].Savings = DefaultCard;
  1121.                         }
  1122.                       }
  1123.                     }
  1124.                   }
  1125.                 }
  1126.                 if (State2 >= B_80) break;
  1127.               }
  1128.           }
  1129.         }
  1130.         if (State1 >= B_78) break;
  1131.       }
  1132.   }
  1133.   {
  1134.     SHORTINT B_83 = From, B_84 = To;
  1135.  
  1136.     if (B_83 <= B_84)
  1137.       for (State1 = B_83;; State1 += 1) {
  1138.         {
  1139.           SHORTINT B_85 = From, B_86 = To;
  1140.  
  1141.           if (B_85 <= B_86)
  1142.             for (State2 = B_85;; State2 += 1) {
  1143.               if (Sets_IsElement((LONGCARD)State2, &DBPtr->A[State1].Defaults)) {
  1144.                 Sets_Include(&DBPtr->A[State2].Users, (LONGCARD)State1);
  1145.               }
  1146.               if (State2 >= B_86) break;
  1147.             }
  1148.         }
  1149.         if (State1 >= B_84) break;
  1150.       }
  1151.   }
  1152.   DFN = From - 1;
  1153.   Sets_Complement(&WorkingSet);
  1154.   {
  1155.     SHORTINT B_87 = 0, B_88 = From - 1;
  1156.  
  1157.     if (B_87 <= B_88)
  1158.       for (State = B_87;; State += 1) {
  1159.         Sets_Exclude(&WorkingSet, (LONGCARD)State);
  1160.         if (State >= B_88) break;
  1161.       }
  1162.   }
  1163.   if (From <= Dfa_EobDefaultState && Dfa_EobDefaultState <= To) {
  1164.     DepthFirstTraversal(Dfa_EobDefaultState);
  1165.   }
  1166.   while (!Sets_IsEmpty(WorkingSet)) {
  1167.     DepthFirstTraversal((SHORTINT)Sets_Select(&WorkingSet));
  1168.   }
  1169.   {
  1170.     SHORTINT B_89 = From, B_90 = To;
  1171.  
  1172.     if (B_89 <= B_90)
  1173.       for (State1 = B_89;; State1 += 1) {
  1174.         State2 = State1 + 1;
  1175.         for (;;) {
  1176.           if (State2 > To) {
  1177.             goto EXIT_2;
  1178.           }
  1179.           if (Sets_IsElement((LONGCARD)State2, &DBPtr->A[State1].Defaults) && Sets_IsElement((LONGCARD)State1, &DBPtr->A[State2].Defaults)) {
  1180.             Sets_Include(&Cyclics, (LONGCARD)State1);
  1181.             Sets_Include(&Cyclics, (LONGCARD)State2);
  1182.             goto EXIT_2;
  1183.           }
  1184.           INC(State2);
  1185.         } EXIT_2:;
  1186.         if (State1 >= B_90) break;
  1187.       }
  1188.   }
  1189.   Sets_AssignEmpty(&Marked);
  1190.   Sets_AssignEmpty(&WorkingSet);
  1191.   Sets_Complement(&WorkingSet);
  1192.   {
  1193.     SHORTINT B_91 = 0, B_92 = From - 1;
  1194.  
  1195.     if (B_91 <= B_92)
  1196.       for (State = B_91;; State += 1) {
  1197.         Sets_Exclude(&WorkingSet, (LONGCARD)State);
  1198.         if (State >= B_92) break;
  1199.       }
  1200.   }
  1201.   while (!Sets_IsEmpty(WorkingSet)) {
  1202.     State = DBPtr->A[Sets_Select(&WorkingSet)].DFNToState;
  1203.     Sets_Assign(&Current, DBPtr->A[State].Defaults);
  1204.     Sets_Intersection(&Current, Cyclics);
  1205.     Sets_Include(&Current, (LONGCARD)State);
  1206.     Sets_Assign(&Next, Current);
  1207.     {
  1208.       LONGCARD B_93 = Sets_Minimum(&Next), B_94 = Sets_Maximum(&Next);
  1209.  
  1210.       if (B_93 <= B_94)
  1211.         for (i = B_93;; i += 1) {
  1212.           if (!Sets_IsElement(i, &Dfa_CyclicStates)) {
  1213.             Sets_Exclude(&Next, i);
  1214.           }
  1215.           if (i >= B_94) break;
  1216.         }
  1217.     }
  1218.     if (From <= Dfa_EobDefaultState && Dfa_EobDefaultState <= To && Sets_IsElement((LONGCARD)Dfa_EobDefaultState, &Current)) {
  1219.       State = Dfa_EobDefaultState;
  1220.     } else if (!Sets_IsEmpty(Next)) {
  1221.       State = Sets_Select(&Next);
  1222.     } else {
  1223.       State = Sets_Select(&Current);
  1224.     }
  1225.     Sets_AssignElmt(&Current, (LONGCARD)State);
  1226.     Sets_Include(&Marked, (LONGCARD)State);
  1227.     while (!Sets_IsEmpty(Current)) {
  1228.       Sets_AssignEmpty(&Next);
  1229.       while (!Sets_IsEmpty(Current)) {
  1230.         State1 = Sets_Extract(&Current);
  1231.         Sets_Exclude(&WorkingSet, (LONGCARD)DBPtr->A[State1].DFN);
  1232.         Sets_Assign(&Successors, DBPtr->A[State1].Users);
  1233.         while (!Sets_IsEmpty(Successors)) {
  1234.           State2 = Sets_Extract(&Successors);
  1235.           if (!Sets_IsElement((LONGCARD)State2, &Marked)) {
  1236.             Dfa_PutDefault(State2, State1);
  1237.             Sets_Include(&Next, (LONGCARD)State2);
  1238.             Sets_Include(&Marked, (LONGCARD)State2);
  1239.           }
  1240.         }
  1241.       }
  1242.       Sets_Assign(&Current, Next);
  1243.     }
  1244.   }
  1245.   {
  1246.     SHORTINT B_95 = From, B_96 = To;
  1247.  
  1248.     if (B_95 <= B_96)
  1249.       for (State1 = B_95;; State1 += 1) {
  1250.         if (Dfa_GetDefault(State1) == Dfa_DNoState) {
  1251.           DBPtr->A[State1].Savings = 0;
  1252.           if (!Sets_IsEmpty(DBPtr->A[State1].Domain)) {
  1253.             Sets_Assign(&Domain1, DBPtr->A[State1].Domain);
  1254.             {
  1255.               SHORTINT B_97 = From, B_98 = To;
  1256.  
  1257.               if (B_97 <= B_98)
  1258.                 for (State2 = B_97;; State2 += 1) {
  1259.                   if (State1 != State2) {
  1260.                     Sets_Assign(&Domain2, DBPtr->A[State2].Domain);
  1261.                     if (Sets_IsStrictSubset(Domain2, Domain1)) {
  1262.                       if (Sets_Card(&DBPtr->A[State2].Domain) >= DBPtr->A[State1].Savings) {
  1263.                         {
  1264.                           CHAR B_99 = Dfa_GetFirst(State2), B_100 = Dfa_GetLast(State2);
  1265.  
  1266.                           if (B_99 <= B_100)
  1267.                             for (Ch = B_99;; Ch += 1) {
  1268.                               State = Dfa_GetTable(State2, Ch);
  1269.                               if (State != Dfa_DNoState && State != Dfa_GetTable(State1, Ch)) {
  1270.                                 Sets_Exclude(&Domain2, ORD(Ch));
  1271.                               }
  1272.                               if (Ch >= B_100) break;
  1273.                             }
  1274.                         }
  1275.                         DefaultCard = Sets_Card(&Domain2);
  1276.                         if (DefaultCard > 0) {
  1277.                           if (DefaultCard == DBPtr->A[State1].Savings) {
  1278.                             Sets_Include(&Current, (LONGCARD)State2);
  1279.                           } else if (DefaultCard > DBPtr->A[State1].Savings) {
  1280.                             Sets_AssignElmt(&Current, (LONGCARD)State2);
  1281.                             DBPtr->A[State1].Savings = DefaultCard;
  1282.                           }
  1283.                         }
  1284.                       }
  1285.                     }
  1286.                   }
  1287.                   if (State2 >= B_98) break;
  1288.                 }
  1289.             }
  1290.             if (DBPtr->A[State1].Savings > 0) {
  1291.               Sets_Assign(&Next, Current);
  1292.               {
  1293.                 LONGCARD B_101 = Sets_Minimum(&Next), B_102 = Sets_Maximum(&Next);
  1294.  
  1295.                 if (B_101 <= B_102)
  1296.                   for (i = B_101;; i += 1) {
  1297.                     if (!Sets_IsElement(i, &Dfa_CyclicStates)) {
  1298.                       Sets_Exclude(&Next, i);
  1299.                     }
  1300.                     if (i >= B_102) break;
  1301.                   }
  1302.               }
  1303.               if (From <= Dfa_EobDefaultState && Dfa_EobDefaultState <= To && Sets_IsElement((LONGCARD)Dfa_EobDefaultState, &Current)) {
  1304.                 State = Dfa_EobDefaultState;
  1305.               } else if (!Sets_IsEmpty(Next)) {
  1306.                 State = Sets_Select(&Next);
  1307.               } else {
  1308.                 State = Sets_Select(&Current);
  1309.               }
  1310.               Dfa_PutDefault(State1, State);
  1311.             }
  1312.           }
  1313.         }
  1314.         if (State1 >= B_96) break;
  1315.       }
  1316.   }
  1317.   {
  1318.     SHORTINT B_103 = From, B_104 = To;
  1319.  
  1320.     if (B_103 <= B_104)
  1321.       for (State1 = B_103;; State1 += 1) {
  1322.         DefaultState = Dfa_GetDefault(State1);
  1323.         if (DefaultState != Dfa_DNoState) {
  1324.           {
  1325.             CHAR B_105 = Dfa_GetFirst(State1), B_106 = Dfa_GetLast(State1);
  1326.  
  1327.             if (B_105 <= B_106)
  1328.               for (Ch = B_105;; Ch += 1) {
  1329.                 State = Dfa_GetTable(DefaultState, Ch);
  1330.                 if (State != Dfa_DNoState && State == Dfa_GetTable(State1, Ch)) {
  1331.                   Dfa_PutTable(State1, Ch, Dfa_DNoState);
  1332.                 }
  1333.                 if (Ch >= B_106) break;
  1334.               }
  1335.           }
  1336.           INC1(Dfa_DefaultSavings, DBPtr->A[State1].Savings);
  1337.         }
  1338.         if (State1 >= B_104) break;
  1339.       }
  1340.   }
  1341.   {
  1342.     SHORTINT B_107 = From, B_108 = To;
  1343.  
  1344.     if (B_107 <= B_108)
  1345.       for (State = B_107;; State += 1) {
  1346.         Sets_ReleaseSet(&DBPtr->A[State].Domain);
  1347.         Sets_ReleaseSet(&DBPtr->A[State].Defaults);
  1348.         Sets_ReleaseSet(&DBPtr->A[State].Users);
  1349.         if (State >= B_108) break;
  1350.       }
  1351.   }
  1352.   Sets_ReleaseSet(&Domain1);
  1353.   Sets_ReleaseSet(&Domain2);
  1354.   Sets_ReleaseSet(&Marked);
  1355.   Sets_ReleaseSet(&WorkingSet);
  1356.   Sets_ReleaseSet(&Cyclics);
  1357.   Sets_ReleaseSet(&Current);
  1358.   Sets_ReleaseSet(&Next);
  1359.   Sets_ReleaseSet(&Successors);
  1360.   DynArray_ReleaseArray((ADDRESS *)&DBPtr, &DBSize, (LONGINT)sizeof(DBElmt));
  1361.   G_5_DBPtr = L_5;
  1362.   G_6_WorkingSet = L_6;
  1363.   G_7_Marked = L_7;
  1364.   G_8_DFN = L_8;
  1365.   G_9_To = L_9;
  1366.   G_10_From = L_10;
  1367. }
  1368.  
  1369. void BEGIN_Dfa()
  1370. {
  1371.   static BOOLEAN has_been_called = FALSE;
  1372.  
  1373.   if (!has_been_called) {
  1374.     has_been_called = TRUE;
  1375.  
  1376.     BEGIN_Sets();
  1377.     BEGIN_General();
  1378.     BEGIN_DynArray();
  1379.     BEGIN_Sets();
  1380.     BEGIN_IO();
  1381.     BEGIN_Layout();
  1382.     BEGIN_GenTabs();
  1383.     BEGIN_Classes();
  1384.  
  1385.     Dfa_LastCh = ((CHAR)'\177');
  1386.     Dfa_DStateCount = 0;
  1387.     TableSize = InitialTableSize;
  1388.     DynArray_MakeArray((ADDRESS *)&TablePtr, &TableSize, (LONGINT)sizeof(DStateInfo));
  1389.   }
  1390. }
  1391.